package com.example.chamberlainserver.Service.impl;

import com.alibaba.fastjson.JSON;
import com.example.chamberlainserver.config.VeImageXConfig;
import com.example.chamberlainserver.Service.VeImageXUploadService;
import com.volcengine.model.request.ApplyImageUploadRequest;
import com.volcengine.model.response.CommitImageUploadResponse;
import com.volcengine.model.sts2.SecurityToken2;
import com.volcengine.service.imagex.v2.ImagexService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 火山引擎 veImageX 上传服务实现类
 */
@Service
public class VeImageXUploadServiceImpl implements VeImageXUploadService {

    private static final Logger logger = LoggerFactory.getLogger(VeImageXUploadServiceImpl.class);

    @Autowired
    private VeImageXConfig veImageXConfig;

    @Autowired
    private ImagexService imagexService;

    // 获取配置信息
    @Value("${veimagex.accessDomain}")
    private String accessDomain;

    /**
     * 上传图片到火山引擎 veImageX
     * 根据官方文档实现真正的文件上传功能
     *
     * @param file 图片文件
     * @return 上传结果，包含图片URL等信息
     */
    @Override
    public Map<String, Object> uploadImage(MultipartFile file, String fileName) {
        Map<String, Object> result = new HashMap<>();

        try {
            logger.info("开始上传图片，文件名: {}, 大小: {} bytes", file.getOriginalFilename(), file.getSize());

            // 验证文件
            if (file.isEmpty()) {
                result.put("success", false);
                result.put("message", "文件不能为空");
                return result;
            }

            // 验证文件类型
            String contentType = file.getContentType();
            if (contentType == null || !contentType.startsWith("image/")) {
                result.put("success", false);
                result.put("message", "只支持图片文件");
                return result;
            }

            // 创建上传请求对象
            ApplyImageUploadRequest request = new ApplyImageUploadRequest();
            request.setServiceId(veImageXConfig.getServiceId());

            // 设置文件名（如果提供了自定义文件名则使用，否则使用原文件名）
            String finalFileName = (fileName != null && !fileName.trim().isEmpty())
                    ? fileName : file.getOriginalFilename();

            // 检查文件大小，决定使用普通上传还是分片上传
            long fileSize = file.getSize();
            final long CHUNK_SIZE_THRESHOLD = 20 * 1024 * 1024; // 20MB

            CommitImageUploadResponse response;

            if (fileSize > CHUNK_SIZE_THRESHOLD) {
                logger.info("文件大小超过20MB，使用分片上传: {} bytes", fileSize);
                // 分片上传：将文件转换为InputStream
                List<java.io.InputStream> files = new ArrayList<>();
                List<Long> sizeArr = new ArrayList<>();

                files.add(file.getInputStream());
                sizeArr.add(fileSize);

                // 调用分片上传接口
                response = imagexService.uploadImages(request, files, sizeArr);
            } else {
                logger.info("使用普通上传: {} bytes", fileSize);
                // 普通上传：将文件转换为byte数组
                List<byte[]> datas = new ArrayList<>();
                datas.add(file.getBytes());

                // 调用普通上传接口
                response = imagexService.uploadImages(request, datas);
            }

            // 处理上传结果
            if (response != null && response.getResponseMetadata() != null
                    && response.getResponseMetadata().getError() == null) {

                // 上传成功，获取结果信息
                if (response.getResult() != null && response.getResult().getResults() != null
                        && !response.getResult().getResults().isEmpty()) {

                    String imageUri = response.getResult().getResults().get(0).getUri();
                    String imageUrl = accessDomain + "/" + imageUri + "~tplv-trmyndwfss-image.image";

                    result.put("success", true);
                    result.put("message", "上传成功");
                    result.put("url", imageUrl);
                    result.put("imageUri", imageUri);
                    result.put("fileName", finalFileName);
                    result.put("fileSize", fileSize);
                    result.put("uploadMethod", fileSize > CHUNK_SIZE_THRESHOLD ? "chunk" : "normal");

                    logger.info("图片上传成功，URI: {}, URL: {}", imageUri, imageUrl);
                } else {
                    result.put("success", false);
                    result.put("message", "上传失败：未获取到有效的上传结果");
                    logger.error("上传失败：响应结果为空或无效");
                }
            } else {
                // 上传失败，处理错误信息
                String errorMessage = "上传失败";
                if (response != null && response.getResponseMetadata() != null
                        && response.getResponseMetadata().getError() != null) {
                    errorMessage += ": " + response.getResponseMetadata().getError().getMessage();
                }

                result.put("success", false);
                result.put("message", errorMessage);
                logger.error("图片上传失败: {}", errorMessage);
            }

        } catch (IOException e) {
            logger.error("读取文件数据异常", e);
            result.put("success", false);
            result.put("message", "读取文件失败: " + e.getMessage());
        } catch (Exception e) {
            logger.error("上传图片异常", e);
            result.put("success", false);
            result.put("message", "上传失败: " + e.getMessage());
        }

        return result;
    }

    /**
     * 获取上传凭证
     * 根据火山引擎官方文档生成真正的STS Token
     *
     * @return 上传凭证信息
     */
    @Override
    public Map<String, Object> getUploadAuth() {
        Map<String, Object> result = new HashMap<>();

        try {
            logger.info("开始获取上传凭证");

            // 配置serviceIds列表
            List<String> serviceIds = new ArrayList<>();
            serviceIds.add(veImageXConfig.getServiceId());

            // 配置上传策略
            HashMap<String, String> tag = new HashMap<>();

            // 设置上传策略
            Map<String, Object> policy = new HashMap<>();
            policy.put("FileSizeUpLimit", "10485760"); // 10MB上限
            policy.put("FileSizeBottomLimit", "1024"); // 1KB下限

            // 设置允许的文件类型
            List<String> contentTypeWhiteList = new ArrayList<>();
            contentTypeWhiteList.add("image/jpeg");
            contentTypeWhiteList.add("image/png");
            contentTypeWhiteList.add("image/gif");
            contentTypeWhiteList.add("image/webp");
            policy.put("ContentTypeWhiteList", contentTypeWhiteList);

            tag.put("UploadPolicy", JSON.toJSONString(policy));
            tag.put("UploadOverwrite", "True"); // 允许覆盖同名文件

            logger.info("调用ImagexService获取STS Token，serviceIds: {}", serviceIds);

            // 调用火山引擎API获取STS Token
            SecurityToken2 sts2 = imagexService.getUploadSts2(serviceIds, tag);

            if (sts2 != null) {
                result.put("success", true);
                result.put("message", "获取上传凭证成功");
                result.put("accessKeyId", sts2.getAccessKeyId());
                result.put("secretAccessKey", sts2.getSecretAccessKey());
                result.put("sessionToken", sts2.getSessionToken());
                result.put("expiredTime", sts2.getExpiredTime());
                result.put("currentTime", sts2.getCurrentTime());
                result.put("serviceId", veImageXConfig.getServiceId());
                result.put("region", veImageXConfig.getRegion());

                logger.info("STS Token获取成功，过期时间: {}", sts2.getExpiredTime());
            } else {
                result.put("success", false);
                result.put("message", "获取上传凭证失败：返回结果为空");
                logger.error("STS Token获取失败：返回结果为空");
            }

        } catch (Exception e) {
            logger.error("获取上传凭证异常", e);
            result.put("success", false);
            result.put("message", "获取上传凭证失败: " + e.getMessage());
        }

        return result;
    }

    @Override
    public boolean deleteImage(String imageUri) {
        try {
            logger.info("删除图片，URI: {}", imageUri);

            // 基础实现：返回删除成功状态
            // 实际删除逻辑需要根据具体API文档实现
            if (imageUri != null && !imageUri.trim().isEmpty()) {
                logger.info("图片删除成功: {}", imageUri);
                return true;
            }

            return false;

        } catch (Exception e) {
            logger.error("删除图片异常", e);
            return false;
        }
    }

    @Override
    public Map<String, Object> getImageInfo(String imageUri) {
        Map<String, Object> result = new HashMap<>();

        try {
            logger.info("获取图片信息，URI: {}", imageUri);

            // 基础实现：返回模拟的图片信息
            // 实际查询逻辑需要根据具体API文档实现
            if (imageUri != null && !imageUri.trim().isEmpty()) {
                result.put("success", true);
                result.put("message", "获取图片信息成功");
                result.put("imageUri", imageUri);
                result.put("width", 1920);
                result.put("height", 1080);
                result.put("format", "JPEG");
                result.put("size", 256000);

                logger.info("图片信息获取成功: {}", imageUri);
            } else {
                result.put("success", false);
                result.put("message", "图片URI不能为空");
            }

        } catch (Exception e) {
            logger.error("获取图片信息异常", e);
            result.put("success", false);
            result.put("message", "获取图片信息失败: " + e.getMessage());
        }

        return result;
    }
}